package com.ylfstu.map_;

import java.util.HashMap;
@SuppressWarnings({"all"})
public class HashMapSource1 {
    public static void main(String[] args) {
        HashMap hashMap = new HashMap();
        hashMap.put("java", 10);
        hashMap.put("php", 10);
        hashMap.put("java", 20);

        System.out.println(hashMap);

        /*老韩解读 HashMap 的源码+图解
        1. 执行构造器 new HashMap()
           初始化加载因子 loadfactor = 0.75
           HashMap$Node[] table = null
        2. 执行 put 调用 hash 方法，计算 key 的 hash 值 (h = key.hashCode()) ^ (h >>> 16)
           public V put(K key, V value) {//K = "java" value = 10
               return putVal(hash(key), key, value, false, true);
           }
        3. 执行 putVal
         final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
                Node<K,V>[] tab; Node<K,V> p; int n, i;
                //如果底层的 table 数组为 null, 或者 length =0 , 就扩容
                if ((tab = table) == null || (n = tab.length) == 0)
                    n = (tab = resize()).length;
                //取出 hash 值对应的 table 的索引位置的 Node, 如果为 null, 就直接把加入的 k-v
                //, 创建一个 Node ,加入该位置
                if ((p = tab[i = (n - 1) & hash]) == null)
                    tab[i] = newNode(hash, key, value, null);
                else {
                    Node<K,V> e; K k;
                    // 如果 table 的索引位置的 key 的 hash 相同和新的 key 的 hash 值相同，
                    // 并 满足(table 现有的结点的 key 和准备添加的 key 是同一个对象 || equals 返回真)
                    // 就认为不能加入新的 k-v
                    if (p.hash == hash &&
                        ((k = p.key) == key || (key != null && key.equals(k))))
                        e = p;
                    else if (p instanceof TreeNode)//如果当前的 table 已有的 Node 是红黑树，就按照红黑树的方式处理
                        e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                    else {
                        //如果找到的结点，后面是链表，就循环比较
                        for (int binCount = 0; ; ++binCount) { //死循环
                            if ((e = p.next) == null) { //如果整个链表，没有和他相同,就加到该链表的最后
                                p.next = newNode(hash, key, value, null);
                                //加入后，判断当前链表的个数，是否已经到 8 个，到 8 个后
                                //就调用 treeifyBin 方法进行红黑树的转换
                                if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                                    treeifyBin(tab, hash);
                                break;
                            }
                            if (e.hash == hash && //如果在循环比较过程中,发现有相同,就break,就只是替换value
                                ((k = e.key) == key || (key != null && key.equals(k))))
                                break;
                            p = e;
                        }
                    }
                    if (e != null) { // existing mapping for key
                        V oldValue = e.value;
                        if (!onlyIfAbsent || oldValue == null)
                            e.value = value;
                        afterNodeAccess(e);
                        return oldValue;
                    }
                }
                ++modCount;
                //只要向table加了一个元素，size就++
                if (++size > threshold)
                    resize();
                afterNodeInsertion(evict);
                return null;
            }

            4. 关于树化(转成红黑树)
            //如果 table 为 null ,或者大小还没有到 64，暂时不树化，而是进行扩容.
            //否则才会真正的树化 -> 减枝
            final void treeifyBin(Node<K,V>[] tab, int hash) {
            int n, index; Node<K,V> e;
            if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
                resize();

         */

    }
}